home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #1 / Amiga Plus CD - 2000 - No. 1.iso / Tools / Dev / AmigaAMP-PDK / Skeleton.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-03  |  10.1 KB  |  269 lines
  1.  
  2.  
  3. /*****************************************************************************/
  4. /*                                                                           */
  5. /*                         AmigaAMP Plugin skeleton v1.2                     */
  6. /*                                                                           */
  7. /*                     Written December 1998  by Thomas Wenzel               */
  8. /*                                                                           */
  9. /*               Adapted to work with VBCC by Thomas Jensen Jan 1999         */
  10. /*                                                                           */
  11. /*****************************************************************************/
  12. /*                                                                           */
  13. /* This is the basic recommended framework for every AmigaAMP plugin.        */
  14. /* To make it as easy as possible all plugins are normal AmigaDOS            */
  15. /* executables which can be launched and stopped at any time.                */
  16. /*                                                                           */
  17. /* This sourcecode and executable are free for non-commercial use only!      */
  18. /*                                                                           */
  19. /* Hint: You may use as many printf's or kprintf's as you like for debugging */
  20. /* purposes. However, before releasing the plugin, please remove all stdio   */
  21. /* and rawio functions and compile with NODEBUG NOSTDIO options set.         */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include <time.h>
  29. #include <math.h>
  30.  
  31. #include <exec/types.h>
  32. #include <exec/memory.h>
  33. #include <proto/exec.h>
  34. #include <proto/dos.h>
  35. #include <proto/intuition.h>
  36. #include <proto/graphics.h>
  37.  
  38. #include <dos/dostags.h>
  39. #include <graphics/gfxbase.h>
  40.  
  41. #include "trackinfo.h"
  42.  
  43. BOOL PluginInit(void);
  44. void PluginExit(void);
  45. void PluginLoop(void);
  46. void ShowRequester(char *Text, char *Button);
  47.  
  48. /***************************************************************************/
  49. /* This is the global variables section. Don't change anything here unless */
  50. /* you know what you're doing!                                             */
  51. /***************************************************************************/
  52.  
  53. BYTE             PluginSignal;
  54. ULONG            PluginMask;
  55. BOOL             Accepted;
  56. struct Process   *PluginTask;
  57. struct MsgPort   *PluginMP;
  58. struct MsgPort   *PluginRP;
  59. BYTE             InfoSignal; // v1.2
  60. ULONG            InfoMask;   // v1.2
  61. struct TrackInfo *tinfo;     // v1.2
  62.  
  63. UWORD    *PluginRawL;
  64. UWORD    *PluginRawR;
  65. UWORD    *SpecRawL;
  66. UWORD    *SpecRawR;
  67.  
  68. struct PluginMessage {
  69.     struct Message msg;
  70.     ULONG          PluginMask;
  71.     struct Process *PluginTask;
  72.     UWORD          **SpecRawL;
  73.     UWORD          **SpecRawR;
  74.     BOOL           Accepted;
  75.  
  76.     /* All data beyond this point is new for v1.2.                         */
  77.     /* AmigaAMP v2.5 and up will detect this new data and act accordingly. */
  78.     /* Older versions of AmigaAMP will simply ignore it.                   */
  79.  
  80.     ULONG            InfoMask;
  81.     struct TrackInfo **tinfo;
  82.     ULONG            reserved;
  83. };
  84.  
  85. /***************************************************************************/
  86. /* This is the main part. Again, don't change anything here if you haven't */
  87. /* got a very good reason to do so!                                        */
  88. /***************************************************************************/
  89.  
  90. int main(void) {
  91.     struct PluginMessage *PluginMsg;
  92.     struct PluginMessage *ReplyMsg;
  93.  
  94.     /* (TJ) added for VBCC compatibility */
  95.     #ifndef __SASC
  96.     IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 36);
  97.     if(IntuitionBase == NULL) {
  98.         printf("Unable to open intuition.library V36+ (OS 2.1 required)\n");
  99.         exit(5);
  100.     }
  101.     #endif
  102.  
  103.     /* Allocate all user resources */
  104.     if(PluginInit()) {
  105.         /* Check if a plugin capable instance of AmigaAMP is running */
  106.         if(PluginMP=FindPort("AmigaAMP plugin port"))    {
  107.             /* Allocate a sigbit for receiving signals FROM AmigaAMP */
  108.             PluginTask   = (struct Process *)FindTask(NULL);
  109.             PluginSignal = AllocSignal(-1);
  110.             InfoSignal   = AllocSignal(-1);              // v1.2
  111.             if(PluginSignal != -1 && InfoSignal != -1) { // v1.2
  112.                 InfoMask   = 1L << InfoSignal;             // v1.2
  113.                 PluginMask = 1L << PluginSignal;
  114.  
  115.                 /* Allocate a message and reply port for sending messages TO AmigaAMP */
  116.                 PluginMsg=AllocVec(sizeof(struct PluginMessage), MEMF_PUBLIC|MEMF_CLEAR);
  117.                 PluginRP=CreatePort(0,0);
  118.  
  119.                 /* Tell AmigaAMP all the details it needs to know */
  120.                 PluginMsg->msg.mn_Node.ln_Type = NT_MESSAGE;
  121.                 PluginMsg->msg.mn_Length       = sizeof(struct PluginMessage);
  122.                 PluginMsg->msg.mn_ReplyPort    = PluginRP;
  123.                 PluginMsg->PluginMask          = PluginMask;
  124.                 PluginMsg->PluginTask          = PluginTask;
  125.                 PluginMsg->SpecRawL            = &SpecRawL;
  126.                 PluginMsg->SpecRawR            = &SpecRawR;
  127.                 PluginMsg->InfoMask            = InfoMask;  // v1.2
  128.                 PluginMsg->tinfo               = &tinfo;    // v1.2
  129.                 PluginMsg->reserved            = 0;         // v1.2
  130.                 PutMsg(PluginMP, (struct Message *)PluginMsg);
  131.                 /* Wait for a reply */
  132.                 WaitPort(PluginRP);
  133.                 /* Let's see if AmigaAMP accepted our registration attempt */
  134.                 if(ReplyMsg = (struct PluginMessage *)GetMsg(PluginRP)) Accepted=ReplyMsg->Accepted;
  135.                 else Accepted=FALSE;
  136.  
  137.                 if(Accepted) {
  138.                     /* If it did, start the plugin loop */
  139.                     PluginLoop();
  140.  
  141.                     /* Tell AmigaAMP that this plugin is going down */
  142.                     PluginMsg->PluginMask          = 0;        /* (TJ) changed from NULL for VBCC compatibility */
  143.                     PluginMsg->PluginTask          = NULL;
  144.                     PluginMsg->SpecRawL            = NULL;
  145.                     PluginMsg->SpecRawR            = NULL;
  146.                     PluginMsg->InfoMask            = 0;     // v1.2
  147.                     PluginMsg->tinfo               = NULL;  // v1.2
  148.                     PluginMsg->reserved            = 0;     // v1.2
  149.                     PutMsg(PluginMP, (struct Message *)PluginMsg);
  150.                     /* Wait for confirmation before going on! */
  151.                     WaitPort(PluginRP);
  152.                     GetMsg(PluginRP);
  153.                     /* Now that AmigaAMP knows that we're gone, we can quit */
  154.                 }
  155.                 else {
  156.                     /* If AmigaAMP didn't accept us, tell the user about it */
  157.                     ShowRequester("Plugin rejected by AmigaAMP!\nPerhaps there's another one running.", "Abort");
  158.                 }
  159.  
  160.                 /* Free all resources */
  161.                 FreeVec(PluginMsg);
  162.                 DeletePort(PluginRP);
  163.                 if(PluginSignal != -1) FreeSignal(PluginSignal);
  164.                 if(InfoSignal   != -1) FreeSignal(InfoSignal);   // v1.2
  165.             }
  166.             else {
  167.                 ShowRequester("Signal allocation failure!", "Abort");
  168.             }
  169.         }
  170.         else {
  171.             ShowRequester("Could not find message port!\nAmigaAMP probably not running.", "Abort");
  172.         }
  173.     }
  174.     else {
  175.         ShowRequester("Plugin initialisation failed!", "Ok");
  176.     }
  177.     /* Free all user resources */
  178.     PluginExit();
  179.  
  180.     /* added for VBCC compatibility */
  181.     #ifndef __SASC
  182.     if(IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  183.     #endif
  184.     return(0);
  185. }
  186.  
  187. /*****************************************************************************/
  188. /* Ok, now for the individual plugin sourcecode.                             */
  189. /* Just like before, we start with the global variables section              */
  190. /*****************************************************************************/
  191.  
  192.  
  193.  
  194. /****************************************************************************/
  195. /* This function will be called once when the plugin is started. You should */
  196. /* allocate all needed resources here. Return TRUE if all went well.        */
  197. /****************************************************************************/
  198.  
  199. BOOL PluginInit(void) {
  200.     /* Initialise everything here. Return TRUE if all went well, FALSE otherwise */
  201.     return(TRUE);
  202. }
  203.  
  204. /******************************************************************************/
  205. /* This function will be called when the plugin is shut down. You should free */
  206. /* all previously allocated resources here.                                   */
  207. /******************************************************************************/
  208.  
  209. void PluginExit(void) {
  210.     /* Free everything you've allocated before */
  211. }
  212.  
  213. /*******************************************************************************/
  214. /* This is the main Plugin Loop. It will receive a signal matching PluginMask  */
  215. /* each time new spectral data is ready. The data is stored in two arrays,     */
  216. /* UWORD SpecRawL[512] and UWORD SpecRawR[512]. The scale is logarithmic, i.e. */
  217. /* 0 means below -96dB, 65535 means 0dB.                                       */
  218. /* No matter how long it takes until your plugin actually processes the data,  */
  219. /* the memory referenced by the array pointers always remains valid!           */
  220. /*                                                                             */
  221. /* Your plugin loop MUST quit when it receives SIGBREAKF_CTRL_C. If you've     */
  222. /* opened a window you should react to the close gadget as well. For full      */
  223. /* screen plugins I strongly recommend checking the ESC key.                   */
  224. /*******************************************************************************/
  225.  
  226. void PluginLoop(void) {
  227.     ULONG Signals;
  228.  
  229.     for(;;) {
  230.  
  231.         /* Wait until there's something to do */
  232.         Signals=Wait(SIGBREAKF_CTRL_C | PluginMask | InfoMask); // v1.2
  233.  
  234.         /* Break received -> quit at once! */
  235.         if(Signals & SIGBREAKF_CTRL_C) break;
  236.  
  237.  
  238.         /* New data has arrived! */
  239.         if(Signals & PluginMask) {
  240.             /*********************************************************/
  241.             /* Visualise SpecRawL[0..511] and SpecRawR[0..512] here! */
  242.             /*********************************************************/
  243.         }
  244.  
  245.         /* New track info has arrived! */
  246.         if(Signals & InfoMask) {
  247.             /**********************************************************************/
  248.             /* If you want to display anything from struct TrackInfo, do it here! */
  249.             /**********************************************************************/
  250.         }
  251.     }
  252. }
  253.  
  254. void ShowRequester(char *Text, char *Button) {
  255.     struct EasyStruct Req;
  256.  
  257.   Req.es_Title        = "AmigaAMP Plugin";
  258.   Req.es_TextFormat   = (UBYTE*)Text;
  259.   Req.es_GadgetFormat = (UBYTE*)Button;
  260.     EasyRequestArgs(NULL, &Req, NULL, NULL);
  261. }
  262.  
  263.  
  264. /* (TJ) added to avoid VBCC linker error */
  265. #ifndef __SASC
  266. struct IntuitionBase *IntuitionBase=NULL;
  267. #endif
  268.  
  269.